home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / dev / gui / mui23dev.lha / MUI / Developer / Oberon / txt / MuiSimple.mod < prev    next >
Text File  |  1994-12-21  |  37KB  |  902 lines
  1. (*------------------------------------------
  2.  
  3.   :Module.      MuiSimple.mod
  4.   :Author.      Albert Weinert  [awn]
  5.   :Address.     Adamsstr. 83 , 51063 Köln, Germany
  6.   :EMail.       a.weinert@darkness.gun.de
  7.   :Phone.       +49-221-613100
  8.   :Revision.    R.4
  9.   :Date.        08-Nov-1994
  10.   :Copyright.   Albert Weinert
  11.   :Language.    Oberon-2
  12.   :Translator.  AmigaOberon V3.20
  13.   :Contents.    Contains the object creation on a simple manner (but not so easy)
  14.   :Contents.    This Module is for "GenCodeOberon" which comes with MuiBuilder 2.0.
  15.   :Remarks.     *Don't mix MuiBasics.mod and MuiSimple.mod objects!!* Do that
  16.   :Remarks.     only if you want do dynamic object creation.
  17.   :Bugs.        <Bekannte Fehler>
  18.   :Usage.       <Angaben zur Anwendung>
  19.   :History.     .1     [awn] 02-Jul-1994 : Erstellt
  20.   :History.     .2     [awn] 19-Aug-1994 : Do some work at the Module,
  21.   :History.     .3     [awn] 26-Sep-1994 : Requires now muimaster.library V8
  22.   :History.            Must changed some object creation to work with MakeObject()
  23.   :History.            because MuiBuilder 2.0 use features oft his.
  24.   :History.     .4     [awn] 08-Nov-1994 : All e.STRPTR replaced with e.LSTRPTR,
  25.   :History.            know the Module needs the V40 Interfaces.
  26.  
  27. --------------------------------------------*)
  28. MODULE MuiSimple;
  29.  
  30. IMPORT e * := Exec,
  31.        I * := Intuition,
  32.        m * := Mui,
  33.        u * := Utility,
  34.        y   :=SYSTEM;
  35.  
  36. TYPE
  37.   Args      * = UNTRACED POINTER TO ArgsDesc;
  38.   ArgsDesc  * = STRUCT END;
  39.  
  40.   HookDef * = PROCEDURE ( hook : u.HookPtr; object : m.Object; args : Args ):LONGINT;
  41.  
  42.   PROCEDURE MakeHook* ( VAR hook : u.Hook; entry: HookDef );
  43.     BEGIN
  44.       u.InitHook( y.ADR( hook ), y.VAL( u.HookFunc, entry ) );
  45.     END MakeHook;
  46.  
  47. (***************************************************************************
  48. ** Class Tree
  49. ****************************************************************************
  50. **
  51. ** rootclass               (BOOPSI's base class)
  52. ** +--Notify               (implements notification mechanism)
  53. **    +--Family            (handles multiple children)
  54. **    !  +--Menustrip      (describes a complete menu strip)
  55. **    !  +--Menu           (describes a single menu)
  56. **    !  \--Menuitem       (describes a single menu item)
  57. **    +--Application       (main class for all applications)
  58. **    +--Window            (handles intuition window related topics)
  59. **    +--Area              (base class for all GUI elements)
  60. **       +--Rectangle      (creates (empty) rectangles)
  61. **       +--Image          (creates images)
  62. **       +--Text           (creates some text)
  63. **       +--String         (creates a string gadget)
  64. **       +--Prop           (creates a proportional gadget)
  65. **       +--Gauge          (creates a fule gauge)
  66. **       +--Scale          (creates a percentage scale)
  67. **       +--Boopsi         (interface to BOOPSI gadgets)
  68. **       +--Colorfield     (creates a field with changeable color)
  69. **       +--List           (creates a line-oriented list)
  70. **       !  +--Floattext   (special list with floating text)
  71. **       !  +--Volumelist  (special list with volumes)
  72. **       !  +--Scrmodelist (special list with screen modes)
  73. **       !  \--Dirlist     (special list with files)
  74. **       +--Group          (groups other GUI elements)
  75. **          +--Register    (handles page groups with titles)
  76. **          +--Virtgroup   (handles virtual groups)
  77. **          +--Scrollgroup (handles virtual groups with scrollers)
  78. **          +--Scrollbar   (creates a scrollbar)
  79. **          +--Listview    (creates a listview)
  80. **          +--Radio       (creates radio buttons)
  81. **          +--Cycle       (creates cycle gadgets)
  82. **          +--Slider      (creates slider gadgets)
  83. **          +--Coloradjust (creates some RGB sliders)
  84. **          +--Palette     (creates a complete palette gadget)
  85. **          +--Colorpanel  (creates a panel of colors)
  86. **          +--Popstring   (base class for popups)
  87. **             +--Popobject(popup a MUI object in a window)
  88. **             \--Popasl   (popup an asl requester)
  89. **
  90. **************************************************************)
  91.   PROCEDURE FamilyObject*{"MuiSimple.FamilyObjectA"} ( tags{9}.. : u.Tag):m.Object;
  92.   PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr ):m.Object;
  93.     BEGIN (* SaveReg+ *)
  94.       RETURN m.NewObject( m.cFamily, u.more, tags );
  95.     END FamilyObjectA;
  96.  
  97.   PROCEDURE MenustripObject*{"MuiSimple.MenustripObjectA"} ( tags{9}.. : u.Tag):m.Object;
  98.   PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr ):m.Object;
  99.     BEGIN (* SaveReg+ *)
  100.       RETURN m.NewObject( m.cMenustrip, u.more, tags );
  101.     END MenustripObjectA;
  102.  
  103.   PROCEDURE MenuObject*{"MuiSimple.MenuObjectA"} ( tags{9}.. : u.Tag):m.Object;
  104.   PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr ):m.Object;
  105.     BEGIN (* SaveReg+ *)
  106.       RETURN m.NewObject( m.cMenu, u.more, tags );
  107.     END MenuObjectA;
  108.  
  109.   PROCEDURE MenuTObject*{"MuiSimple.MenuTObjectA"} ( name {8}: ARRAY OF CHAR; tags{9}.. : u.Tag):m.Object;
  110.   PROCEDURE MenuTObjectA*( name {8}: e.LSTRPTR; tags{9} : u.TagListPtr ):m.Object;
  111.     BEGIN (* SaveReg+ *)
  112.       RETURN m.NewObject( m.cMenu, m.aMenuTitle, name, u.more, tags );
  113.     END MenuTObjectA;
  114.  
  115.   PROCEDURE MenuitemObject*{"MuiSimple.MenuitemObjectA"} ( tags{9}.. : u.Tag):m.Object;
  116.   PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr ):m.Object;
  117.     BEGIN (* SaveReg+ *)
  118.       RETURN m.NewObject( m.cMenuitem, u.more, tags );
  119.     END MenuitemObjectA;
  120.  
  121.   PROCEDURE WindowObject*{"MuiSimple.WindowObjectA"} ( tags{9}.. : u.Tag):m.Object;
  122.   PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr ):m.Object;
  123.     BEGIN (* SaveReg+ *)
  124.       RETURN m.NewObject( m.cWindow, u.more, tags );
  125.     END WindowObjectA;
  126.  
  127.   PROCEDURE ImageObject*{"MuiSimple.ImageObjectA"} ( tags{9}.. : u.Tag): m.Object;
  128.   PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr ): m.Object;
  129.     BEGIN (* SaveReg+ *)
  130.       RETURN m.NewObject( m.cImage, u.more, tags );
  131.     END ImageObjectA;
  132.  
  133.   PROCEDURE BitmapObject*{"MuiSimple.BitmapObjectA"} ( tags{9}.. : u.Tag):m.Object;
  134.   PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr ):m.Object;
  135.     BEGIN (* SaveReg+ *)
  136.       RETURN m.NewObject( m.cBitmap, u.more, tags );
  137.     END BitmapObjectA;
  138.  
  139.   PROCEDURE BodychunkObject*{"MuiSimple.BodychunkObjectA"} ( tags{9}.. : u.Tag):m.Object;
  140.   PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr ):m.Object;
  141.     BEGIN (* SaveReg+ *)
  142.       RETURN m.NewObject( m.cBodychunk, u.more, tags );
  143.     END BodychunkObjectA;
  144.  
  145.   PROCEDURE NotifyObject*{"MuiSimple.NotifyObjectA"} ( tags{9}.. : u.Tag): m.Object;
  146.   PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr ): m.Object;
  147.     BEGIN (* SaveReg+ *)
  148.       RETURN m.NewObject( m.cNotify, u.more, tags );
  149.     END NotifyObjectA;
  150.  
  151.   PROCEDURE ApplicationObject*{"MuiSimple.ApplicationObjectA"} ( tags{9}.. : u.Tag): m.Object;
  152.   PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr ): m.Object;
  153.     BEGIN (* SaveReg+ *)
  154.       RETURN m.NewObject( m.cApplication, u.more, tags );
  155.     END ApplicationObjectA;
  156.  
  157.   PROCEDURE TextObject*{"MuiSimple.TextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  158.   PROCEDURE TextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  159.     BEGIN (* SaveReg+ *)
  160.       RETURN m.NewObject( m.cText, u.more, tags );
  161.     END TextObjectA;
  162.  
  163.   PROCEDURE RectangleObject*{"MuiSimple.RectangleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  164.   PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  165.     BEGIN (* SaveReg+ *)
  166.       RETURN m.NewObject( m.cRectangle, u.more, tags );
  167.     END RectangleObjectA;
  168.  
  169.   PROCEDURE ListObject*{"MuiSimple.ListObjectA"} ( tags{9}.. : u.Tag): m.Object;
  170.   PROCEDURE ListObjectA*( tags{9} : u.TagListPtr ): m.Object;
  171.     BEGIN (* SaveReg+ *)
  172.       RETURN m.NewObject( m.cList, u.more, tags );
  173.     END ListObjectA;
  174.  
  175.   PROCEDURE PropObject*{"MuiSimple.PropObjectA"} ( tags{9}.. : u.Tag): m.Object;
  176.   PROCEDURE PropObjectA*( tags{9} : u.TagListPtr ): m.Object;
  177.     BEGIN (* SaveReg+ *)
  178.       RETURN m.NewObject( m.cProp, u.more, tags );
  179.     END PropObjectA;
  180.  
  181.   PROCEDURE StringObject*{"MuiSimple.StringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  182.   PROCEDURE StringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  183.     BEGIN (* SaveReg+ *)
  184.       RETURN m.NewObject( m.cString, u.more, tags );
  185.     END StringObjectA;
  186.  
  187.   PROCEDURE ScrollbarObject*{"MuiSimple.ScrollbarObjectA"} ( tags{9}.. : u.Tag): m.Object;
  188.   PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr ): m.Object;
  189.     BEGIN (* SaveReg+ *)
  190.       RETURN m.NewObject( m.cScrollbar, u.more, tags );
  191.     END ScrollbarObjectA;
  192.  
  193.   PROCEDURE ListviewObject*{"MuiSimple.ListviewObjectA"} ( tags{9}.. : u.Tag): m.Object;
  194.   PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr ): m.Object;
  195.     BEGIN (* SaveReg+ *)
  196.       RETURN m.NewObject( m.cListview, u.more, tags );
  197.     END ListviewObjectA;
  198.  
  199.   PROCEDURE RadioObject*{"MuiSimple.RadioObjectA"} ( tags{9}.. : u.Tag): m.Object;
  200.   PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr ): m.Object;
  201.     BEGIN (* SaveReg+ *)
  202.       RETURN m.NewObject( m.cRadio, u.more, tags );
  203.     END RadioObjectA;
  204.  
  205.   PROCEDURE VolumelistObject*{"MuiSimple.VolumelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  206.   PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  207.     BEGIN (* SaveReg+ *)
  208.       RETURN m.NewObject( m.cVolumelist, u.more, tags );
  209.     END VolumelistObjectA;
  210.  
  211.   PROCEDURE FloattextObject*{"MuiSimple.FloattextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  212.   PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  213.     BEGIN (* SaveReg+ *)
  214.       RETURN m.NewObject( m.cFloattext, u.more, tags );
  215.     END FloattextObjectA;
  216.  
  217.   PROCEDURE DirlistObject*{"MuiSimple.DirlistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  218.   PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  219.     BEGIN (* SaveReg+ *)
  220.       RETURN m.NewObject( m.cDirlist, u.more, tags );
  221.     END DirlistObjectA;
  222.  
  223.   PROCEDURE SliderObject*{"MuiSimple.SliderObjectA"} ( tags{9}.. : u.Tag): m.Object;
  224.   PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr ): m.Object;
  225.     BEGIN (* SaveReg+ *)
  226.       RETURN m.NewObject( m.cSlider, u.more, tags );
  227.     END SliderObjectA;
  228.  
  229.   PROCEDURE CycleObject*{"MuiSimple.CycleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  230.   PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  231.     BEGIN (* SaveReg+ *)
  232.       RETURN m.NewObject( m.cCycle, u.more, tags );
  233.     END CycleObjectA;
  234.  
  235.   PROCEDURE GaugeObject*{"MuiSimple.GaugeObjectA"} ( tags{9}.. : u.Tag): m.Object;
  236.   PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr ): m.Object;
  237.     BEGIN (* SaveReg+ *)
  238.       RETURN m.NewObject( m.cGauge, u.more, tags );
  239.     END GaugeObjectA;
  240.  
  241.   PROCEDURE ScaleObject*{"MuiSimple.ScaleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  242.   PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  243.     BEGIN (* SaveReg+ *)
  244.       RETURN m.NewObject( m.cScale, u.more, tags );
  245.     END ScaleObjectA;
  246.  
  247.   PROCEDURE BoopsiObject*{"MuiSimple.BoopsiObjectA"} ( tags{9}.. : u.Tag): m.Object;
  248.   PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr ): m.Object;
  249.     BEGIN (* SaveReg+ *)
  250.       RETURN m.NewObject( m.cBoopsi, u.more, tags );
  251.     END BoopsiObjectA;
  252.  
  253.   PROCEDURE ColorfieldObject*{"MuiSimple.ColorfieldObjectA"} ( tags{9}.. : u.Tag): m.Object;
  254.   PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr ): m.Object;
  255.     BEGIN (* SaveReg+ *)
  256.       RETURN m.NewObject( m.cColorfield, u.more, tags );
  257.     END ColorfieldObjectA;
  258.  
  259.   PROCEDURE ColorpanelObject*{"MuiSimple.ColorpanelObjectA"} ( tags{9}.. : u.Tag):m.Object;
  260.   PROCEDURE ColorpanelObjectA*( tags{9} : u.TagListPtr ):m.Object;
  261.     BEGIN (* SaveReg+ *)
  262.       RETURN m.NewObject( m.cColorpanel, u.more, tags );
  263.     END ColorpanelObjectA;
  264.  
  265.   PROCEDURE ColoradjustObject*{"MuiSimple.ColoradjustObjectA"} ( tags{9}.. : u.Tag): m.Object;
  266.   PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr ): m.Object;
  267.     BEGIN (* SaveReg+ *)
  268.       RETURN m.NewObject( m.cColoradjust, u.more, tags );
  269.     END ColoradjustObjectA;
  270.  
  271.  PROCEDURE PaletteObject*{"MuiSimple.PaletteObjectA"} ( tags{9}.. : u.Tag): m.Object;
  272.   PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr ): m.Object;
  273.     BEGIN (* SaveReg+ *)
  274.       RETURN m.NewObject( m.cPalette, u.more, tags );
  275.     END PaletteObjectA;
  276.  
  277.   PROCEDURE GroupObject*{"MuiSimple.GroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  278.   PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  279.     BEGIN (* SaveReg+ *)
  280.       RETURN m.NewObject( m.cGroup, u.more, tags );
  281.     END GroupObjectA;
  282.  
  283.   PROCEDURE RegisterObject*{"MuiSimple.RegisterObjectA"} ( tags{9}.. : u.Tag): m.Object;
  284.   PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr ): m.Object;
  285.     BEGIN (* SaveReg+ *)
  286.       RETURN m.NewObject( m.cRegister, u.more, tags );
  287.     END RegisterObjectA;
  288.  
  289.   PROCEDURE VirtgroupObject*{"MuiSimple.VirtgroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  290.   PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  291.     BEGIN (* SaveReg+ *)
  292.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  293.     END VirtgroupObjectA;
  294.  
  295.   PROCEDURE ScrollgroupObject*{"MuiSimple.ScrollgroupObjectA"} ( tags{9}.. : u.Tag ): m.Object;
  296.   PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  297.     BEGIN (* SaveReg+ *)
  298.       RETURN m.NewObject( m.cScrollgroup, u.more, tags );
  299.     END ScrollgroupObjectA;
  300.  
  301.   PROCEDURE PopstringObject*{"MuiSimple.PopstringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  302.   PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  303.     BEGIN (* SaveReg+ *)
  304.       RETURN m.NewObject( m.cPopstring, u.more, tags );
  305.     END PopstringObjectA;
  306.  
  307.   PROCEDURE PopobjectObject*{"MuiSimple.PopobjectObjectA"} ( tags{9}.. : u.Tag): m.Object;
  308.   PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr ): m.Object;
  309.     BEGIN (* SaveReg+ *)
  310.       RETURN m.NewObject( m.cPopobject, u.more, tags );
  311.     END PopobjectObjectA;
  312.  
  313.   PROCEDURE PoplistObject*{"MuiSimple.PoplistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  314.   PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  315.     BEGIN (* SaveReg+ *)
  316.       RETURN m.NewObject( m.cPoplist, u.more, tags );
  317.     END PoplistObjectA;
  318.  
  319.   PROCEDURE PopaslObject*{"MuiSimple.PopaslObjectA"} ( tags{9}.. : u.Tag): m.Object;
  320.   PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr ): m.Object;
  321.     BEGIN (* SaveReg+ *)
  322.       RETURN m.NewObject( m.cPopasl, u.more, tags );
  323.     END PopaslObjectA;
  324.  
  325.   PROCEDURE ScrmodelistObject*{"MuiSimple.ScrmodelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  326.   PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  327.     BEGIN (* SaveReg+ *)
  328.       RETURN m.NewObject( m.cScrmodelist, u.more, tags );
  329.     END ScrmodelistObjectA;
  330.  
  331.   PROCEDURE VGroup*{"MuiSimple.VGroupA"}( tags{9}.. : u.Tag ): m.Object;
  332.   PROCEDURE VGroupA*( tags{9} : u.TagListPtr ): m.Object;
  333.     BEGIN (* SaveReg+ *)
  334.       RETURN m.NewObject( m.cGroup, u.more, tags );
  335.     END VGroupA;
  336.  
  337.   PROCEDURE HGroup*{"MuiSimple.HGroupA"}( tags{9}.. : u.Tag ): m.Object;
  338.   PROCEDURE HGroupA*( tags{9} : u.TagListPtr ): m.Object;
  339.     BEGIN (* SaveReg+ *)
  340.       RETURN m.NewObject( m.cGroup, m.aGroupHoriz, e.true, u.more, tags );
  341.     END HGroupA;
  342.  
  343.   PROCEDURE ColGroup*{"MuiSimple.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  344.   PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  345.     BEGIN (* SaveReg+ *)
  346.       RETURN m.NewObject( m.cGroup, m.aGroupColumns, cols, u.more, tags );
  347.     END ColGroupA;
  348.  
  349.   PROCEDURE RowGroup*{"MuiSimple.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  350.   PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  351.     BEGIN (* SaveReg+ *)
  352.       RETURN m.NewObject( m.cGroup, m.aGroupRows, rows, u.more, tags );
  353.     END RowGroupA;
  354.  
  355.   PROCEDURE PageGroup*{"MuiSimple.PageGroupA"}( tags{9}.. : u.Tag ): m.Object;
  356.   PROCEDURE PageGroupA*( tags{9} : u.TagListPtr ): m.Object;
  357.     BEGIN (* SaveReg+ *)
  358.       RETURN m.NewObject( m.cGroup, m.aGroupPageMode, e.true, u.more, tags );
  359.     END PageGroupA;
  360.  
  361.   PROCEDURE VGroupV*{"MuiSimple.VGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  362.   PROCEDURE VGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  363.     BEGIN (* SaveReg+ *)
  364.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  365.     END VGroupVA;
  366.  
  367.   PROCEDURE HGroupV*{"MuiSimple.HGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  368.   PROCEDURE HGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  369.     BEGIN (* SaveReg+ *)
  370.       RETURN m.NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.more, tags );
  371.     END HGroupVA;
  372.  
  373.   PROCEDURE ColGroupV*{"MuiSimple.ColGroupVA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag ): m.Object;
  374.   PROCEDURE ColGroupVA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  375.     BEGIN (* SaveReg+ *)
  376.       RETURN m.NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.more, tags );
  377.     END ColGroupVA;
  378.  
  379.   PROCEDURE RowGroupV*{"MuiSimple.RowGroupVA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  380.   PROCEDURE RowGroupVA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  381.     BEGIN (* SaveReg+ *)
  382.       RETURN m.NewObject( m.cVirtgroup, m.aGroupRows, rows, u.more, tags);
  383.     END RowGroupVA;
  384.  
  385.   PROCEDURE PageGroupV*{"MuiSimple.PageGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  386.   PROCEDURE PageGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  387.     BEGIN (* SaveReg+ *)
  388.       RETURN m.NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.more, tags );
  389.     END PageGroupVA;
  390.  
  391.   PROCEDURE RegisterGroup*{"MuiSimple.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag ): m.Object;
  392.   PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr ): m.Object;
  393.     BEGIN (* SaveReg+ *)
  394.       RETURN m.NewObject( m.cRegister, m.aRegisterTitles, t, u.more, tags );
  395.     END RegisterGroupA;
  396.  
  397.  
  398. (***************************************************************************
  399. **
  400. ** Baring Procedures
  401. ** ------------------
  402. **
  403. ***************************************************************************)
  404.  
  405.   PROCEDURE HBar*(): m.Object;
  406.     BEGIN (* SaveReg+ *)
  407.       RETURN m.NewObject( m.cRectangle,
  408.                           m.aRectangleHBar, e.true,
  409.                           m.aFixHeight, 2,
  410.                           u.done ) ;
  411.     END HBar;
  412.  
  413.   PROCEDURE VBar*(): m.Object;
  414.     BEGIN (* SaveReg+ *)
  415.       RETURN m.NewObject( m.cRectangle,
  416.                           m.aRectangleVBar, e.true,
  417.                           m.aFixWidth, 2,
  418.                           u.done );
  419.     END VBar;
  420.  
  421. (***************************************************************************
  422. **
  423. ** Spacing Procedures
  424. ** ------------------
  425. **
  426. ***************************************************************************)
  427.  
  428.   PROCEDURE HVSpace*(): m.Object;
  429.     BEGIN (* SaveReg+ *)
  430.       RETURN m.NewObject( m.cRectangle, u.done );
  431.     END HVSpace;
  432.  
  433. (*
  434.  *  PROCEDURE GroupSpacing*( x: LONGINT );
  435.  *  (*  *)
  436.  *    BEGIN (* SaveReg+ *)
  437.  *      TagItem( m.aGroupSpacing, x );
  438.  *    END GroupSpacing;
  439.  *)
  440.  
  441.   PROCEDURE HSpace*( x : LONGINT ): m.Object;
  442.     BEGIN (* SaveReg+ *)
  443.       RETURN m.MakeObject( m.oHSpace, x );
  444.     END HSpace;
  445.  
  446.   PROCEDURE VSpace*( x : LONGINT ): m.Object;
  447.     BEGIN (* SaveReg+ *)
  448.       RETURN m.MakeObject( m.oVSpace, x );
  449.     END VSpace;
  450.  
  451.  
  452.   PROCEDURE HCenterObject*( obj : m.Object ): m.Object;
  453.     VAR spL, spR : m.Object;
  454.     BEGIN (* SaveReg+ *)
  455.       spL := HSpace( 0 );
  456.       spR := HSpace( 0 );
  457.       RETURN HGroup( m.aGroupSpacing, 0,
  458.                      m.aGroupChild, spL,
  459.                      m.aGroupChild, obj,
  460.                      m.aGroupChild, spR,
  461.                      u.end );
  462.     END HCenterObject;
  463.  
  464.   PROCEDURE VCenterObject*( obj : m.Object ): m.Object;
  465.     VAR spO, spU : m.Object;
  466.     BEGIN (* SaveReg+ *)
  467.       spO := VSpace( 0 );
  468.       spU := VSpace( 0 );
  469.       RETURN VGroup( m.aGroupSpacing,0,
  470.                      m.aGroupChild, spO,
  471.                      m.aGroupChild, obj,
  472.                      m.aGroupChild, spU,
  473.                      u.end );
  474.     END VCenterObject;
  475.  
  476.  
  477. (*
  478.  *  PROCEDURE InnerSpacing*( h, v : LONGINT );
  479.  *  (*  *)
  480.  *    BEGIN (* SaveReg+ *)
  481.  *      Tags( m.aInnerLeft   , h,
  482.  *            m.aInnerRight  , h,
  483.  *            m.aInnerTop    , v,
  484.  *            m.aInnerBottom , v,
  485.  *            u.end );
  486.  *    END InnerSpacing;
  487.  *)
  488.  
  489.  
  490. (***************************************************************************
  491. **
  492. ** String-Object
  493. ** -------------
  494. **
  495. ** The following procedure creates a simple string gadget.
  496. **
  497. ***************************************************************************)
  498.  
  499.   PROCEDURE String * {"MuiSimple.StringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  500.   PROCEDURE StringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  501.     BEGIN (* SaveReg+ *)
  502.       RETURN StringObject( m.aFrame, m.vFrameString,
  503.                            m.aStringMaxLen, maxlen,
  504.                            m.aStringContents, contents,
  505.                            u.more, tags );
  506.     END StringA;
  507.  
  508.   PROCEDURE KeyString * {"MuiSimple.KeyStringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  509.   PROCEDURE KeyStringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  510.     BEGIN (* SaveReg+ *)
  511.       RETURN String( contents^, maxlen, m.aControlChar, controlchar, u.more, tags );
  512.     END KeyStringA;
  513.  
  514. (***************************************************************************
  515. **
  516. ** Integer-Object
  517. ** --------------
  518. **
  519. ** The following procedure creates a simple integer string gadget.
  520. **
  521. ***************************************************************************)
  522.  
  523.   PROCEDURE Integer * {"MuiSimple.IntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  524.   PROCEDURE IntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  525.     BEGIN (* SaveReg+ *)
  526.       RETURN StringObject( m.aFrame, m.vFrameString,
  527.                            m.aStringMaxLen, maxlen,
  528.                            m.aStringInteger, contents,
  529.                            m.aStringAccept, y.ADR( "0123456789" ),
  530.                            u.more, tags );
  531.     END IntegerA;
  532.  
  533.   PROCEDURE KeyInteger * {"MuiSimple.KeyIntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2}: CHAR; tags{9}.. : u.Tag ):m.Object;
  534.   PROCEDURE KeyIntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  535.     BEGIN (* SaveReg+ *)
  536.       RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  537.     END KeyIntegerA;
  538.  
  539. (***************************************************************************
  540. **
  541. ** CheckMark-Object
  542. ** ----------------
  543. **
  544. ** The following procedure creates a checkmark gadget.
  545. **
  546. ***************************************************************************)
  547.  
  548.   PROCEDURE CheckMark * {"MuiSimple.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  549.   PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
  550.    BEGIN (* SaveReg+ *)
  551.     RETURN ImageObject( m.aFrame, m.vFrameImageButton,
  552.                         m.aInputMode, m.vInputModeToggle,
  553.                         m.aImageSpec, m.iCheckMark,
  554.                         m.aImageFreeVert, e.true,
  555.                         m.aSelected, checked,
  556.                         m.aBackground, m.iButtonBack,
  557.                         m.aShowSelState, e.false,
  558.                         u.more, tags );
  559.     END CheckMarkA;
  560.  
  561.   PROCEDURE KeyCheckMark *{"MuiSimple.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  562.   PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  563.    BEGIN (* SaveReg+ *)
  564.     RETURN CheckMark( y.VAL(BOOLEAN,SHORT(SHORT(checked))), m.aControlChar, key, u.more, tags );
  565.     END KeyCheckMarkA;
  566.  
  567.  
  568. (***************************************************************************
  569. **
  570. ** Button-Objects
  571. ** --------------
  572. **
  573. ** Note: Use small letters for KeyButtons, e.g.
  574. **       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
  575. **
  576. ***************************************************************************)
  577.  
  578.   PROCEDURE Button* {"MuiSimple.ButtonA"} ( label{8} : ARRAY OF CHAR ): m.Object;
  579.   PROCEDURE ButtonA* (label{8} : y.ADDRESS ):m.Object;
  580.     BEGIN
  581.       RETURN m.MakeObject( m.oButton, label );
  582.     END ButtonA;
  583.             
  584.   PROCEDURE SimpleButton * {"MuiSimple.SimpleButtonA"} ( name{8} : ARRAY OF CHAR ):m.Object;
  585.   PROCEDURE SimpleButtonA * ( name{8} : e.LSTRPTR ):m.Object;
  586.     BEGIN (* SaveReg+ *)
  587.       RETURN m.MakeObject( m.oButton, name );
  588.     END SimpleButtonA;
  589.  
  590.  
  591. (***************************************************************************
  592. **
  593. ** Cycle-Object
  594. ** ------------
  595. **
  596. ***************************************************************************)
  597.  
  598.   PROCEDURE Cycle * {"MuiSimple.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  599.   PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  600.     BEGIN (* SaveReg+ *)
  601.       RETURN CycleObject( m.aCycleEntries, entries, u.more, tags );
  602.     END CycleA;
  603.  
  604.   PROCEDURE KeyCycle * {"MuiSimple.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  605.   PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  606.     BEGIN (* SaveReg+ *)
  607.       RETURN Cycle( entries, m.aControlChar, key, u.more, tags );
  608.     END KeyCycleA;
  609.  
  610. (***************************************************************************
  611. **
  612. ** Radio-Object
  613. ** ------------
  614. **
  615. ***************************************************************************)
  616.  
  617.   PROCEDURE Radio * {"MuiSimple.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  618.   PROCEDURE RadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  619.     BEGIN (* SaveReg+ *)
  620.       RETURN RadioObject( m.aFrame, m.vFrameGroup,
  621.                           m.aFrameTitle, name,
  622.                           m.aRadioEntries, entries,
  623.                           u.more, tags );
  624.     END RadioA;
  625.  
  626.   PROCEDURE KeyRadio * {"MuiSimple.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  627.   PROCEDURE KeyRadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  628.     BEGIN (* SaveReg+ *)
  629.       RETURN Radio( name^, entries, m.aControlChar, key, u.more, tags );
  630.     END KeyRadioA;
  631.  
  632. (***************************************************************************
  633. **
  634. ** Slider-Object
  635. ** -------------
  636. **
  637. ***************************************************************************)
  638.  
  639.   PROCEDURE Slider * {"MuiSimple.SliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  640.   PROCEDURE SliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  641.     BEGIN (* SaveReg+ *)
  642.       RETURN SliderObject( m.aSliderMin, min,
  643.                            m.aSliderMax, max,
  644.                            m.aSliderLevel, level,
  645.                            u.more, tags );
  646.     END SliderA;
  647.  
  648.   PROCEDURE KeySlider * {"MuiSimple.KeySliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  649.   PROCEDURE KeySliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  650.     BEGIN (* SaveReg+ *)
  651.       RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
  652.     END KeySliderA;
  653.  
  654.   PROCEDURE VSlider * {"MuiSimple.VSliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  655.   PROCEDURE VSliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  656.     BEGIN (* SaveReg+ *)
  657.       RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
  658.     END VSliderA;
  659.  
  660.   PROCEDURE KeyVSlider * {"MuiSimple.KeyVSliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  661.   PROCEDURE KeyVSliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  662.     BEGIN (* SaveReg+ *)
  663.       RETURN VSlider( min,  max, level, m.aControlChar, key, u.more, tags );
  664.     END KeyVSliderA;
  665.  
  666. (***************************************************************************
  667. **
  668. ** Scrollbar-Object
  669. ** -------------
  670. **
  671. ***************************************************************************)
  672.  
  673.   PROCEDURE Scrollbar * {"MuiSimple.ScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  674.   PROCEDURE ScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  675.     BEGIN (* SaveReg+ *)
  676.       RETURN ScrollbarObject( m.aSliderMin, min,
  677.                               m.aSliderMax, max,
  678.                               m.aSliderLevel, level,
  679.                               m.aGroupHoriz, e.true,
  680.                               u.more, tags );
  681.     END ScrollbarA;
  682.  
  683.   PROCEDURE KeyScrollbar * {"MuiSimple.KeyScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  684.   PROCEDURE KeyScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  685.     BEGIN (* SaveReg+ *)
  686.       RETURN Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  687.     END KeyScrollbarA;
  688.  
  689.   PROCEDURE VScrollbar * {"MuiSimple.VScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  690.   PROCEDURE VScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  691.     BEGIN (* SaveReg+ *)
  692.       RETURN ScrollbarObject( m.aSliderMin, min,
  693.                               m.aSliderMax, max,
  694.                               m.aSliderLevel, level,
  695.                               u.more, tags );
  696.     END VScrollbarA;
  697.  
  698.   PROCEDURE KeyVScrollbar * {"MuiSimple.KeyVScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  699.   PROCEDURE KeyVScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  700.     BEGIN (* SaveReg+ *)
  701.       RETURN VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  702.     END KeyVScrollbarA;
  703.  
  704. (***************************************************************************
  705. **
  706. ** Button to be used for popup objects
  707. **
  708. ***************************************************************************)
  709.  
  710.   PROCEDURE PopButton* {"MuiSimple.PopButtonA"} ( img{3} : LONGINT ):m.Object;
  711.   PROCEDURE PopButtonA*( img{3} : LONGINT ):m.Object;
  712.     BEGIN (* SaveReg+ *)
  713.       RETURN m.MakeObject( m.oPopButton, img );
  714.     END PopButtonA;
  715.  
  716. (***************************************************************************
  717. **
  718. ** Labeling Objects
  719. ** ----------------
  720. **
  721. ** Labeling objects, e.g. a group of string gadgets,
  722. **
  723. **   Small: |foo   |
  724. **  Normal: |bar   |
  725. **     Big: |foobar|
  726. **    Huge: |barfoo|
  727. **
  728. ** is done using a 2 column group:
  729. **
  730. ** ColGroup(2);
  731. **      Child; Label2( "Small:"  );
  732. **    Child; StringObject; end;
  733. **      Child; Label2( "Normal:" );
  734. **    Child; StringObject; end;
  735. **      Child; Label2( "Big:"    );
  736. **    Child; StringObject; end;
  737. **      Child; Label2( "Huge:"   );
  738. **    Child; StringObject; end;
  739. **    end;
  740. **
  741. ** Note that we have three versions of the label procedure, depending on
  742. ** the frame type of the right hand object:
  743. **
  744. ** Label1(): For use with standard frames (e.g. checkmarks).
  745. ** Label2(): For use with double high frames (e.g. string gadgets).
  746. ** Label() : For use with objects without a frame.
  747. **
  748. ** These procedures ensure that your label will look fine even if the
  749. ** user of your application configured some strange spacing values.
  750. ** If you want to use your own labeling, you'll have to pay attention
  751. ** on this topic yourself.
  752. **
  753. ***************************************************************************)
  754.  
  755.   PROCEDURE LLabel* {"MuiSimple.LLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  756.   PROCEDURE LLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  757.     BEGIN (* SaveReg+ *)
  758.       RETURN m.MakeObject( m.oLabel, label, m.oLabelLeftAligned );
  759.     END LLabelA;
  760.  
  761.   PROCEDURE LLabel1* {"MuiSimple.LLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  762.   PROCEDURE LLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  763.     BEGIN (* SaveReg+ *)
  764.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned );
  765.     END LLabel1A;
  766.  
  767.   PROCEDURE LLabel2* {"MuiSimple.LLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  768.   PROCEDURE LLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  769.     BEGIN (* SaveReg+ *)
  770.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned );
  771.     END LLabel2A;
  772.  
  773.   PROCEDURE Label* {"MuiSimple.LabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  774.   PROCEDURE LabelA * ( label{8} : e.LSTRPTR ):m.Object;
  775.     BEGIN (* SaveReg+ *)
  776.       RETURN m.MakeObject( m.oLabel, label, 0 );
  777.     END LabelA;
  778.  
  779.   PROCEDURE Label1* {"MuiSimple.Label1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  780.   PROCEDURE Label1A * ( label{8} : e.LSTRPTR ):m.Object;
  781.     BEGIN (* SaveReg+ *)
  782.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame );
  783.  
  784.     END Label1A;
  785.  
  786.   PROCEDURE Label2* {"MuiSimple.Label2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  787.   PROCEDURE Label2A * ( label{8} : e.LSTRPTR ):m.Object;
  788.     BEGIN (* SaveReg+ *)
  789.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame );
  790.     END Label2A;
  791.  
  792.   PROCEDURE KeyLabel*{"MuiSimple.KeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  793.   PROCEDURE KeyLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
  794.     BEGIN (* SaveReg+ *)
  795.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  796.     END KeyLabelA;
  797.  
  798.   PROCEDURE KeyLabel1*{"MuiSimple.KeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  799.   PROCEDURE KeyLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  800.     BEGIN (* SaveReg+ *)
  801.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+hichar );
  802.     END KeyLabel1A;
  803.  
  804.   PROCEDURE KeyLabel2*{"MuiSimple.KeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  805.   PROCEDURE KeyLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  806.     BEGIN (* SaveReg+ *)
  807.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  808.     END KeyLabel2A;
  809.  
  810.   PROCEDURE KeyLLabel*{"MuiSimple.KeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  811.   PROCEDURE KeyLLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  812.     BEGIN (* SaveReg+ *)
  813.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  814.     END KeyLLabelA;
  815.  
  816.   PROCEDURE KeyLLabel1*{"MuiSimple.KeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  817.   PROCEDURE KeyLLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  818.     BEGIN (* SaveReg+ *)
  819.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
  820.     END KeyLLabel1A;
  821.  
  822.   PROCEDURE KeyLLabel2*{"MuiSimple.KeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  823.   PROCEDURE KeyLLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  824.     BEGIN (* SaveReg+ *)
  825.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  826.     END KeyLLabel2A;
  827.  
  828. (***************************************************************************
  829. **
  830. ** Controlling Objects
  831. ** -------------------
  832. **
  833. ** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
  834. ** calls:
  835. **
  836. **
  837. **    VAR x : e.LSTRPTR;
  838. **
  839. **    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
  840. **    Get(obj,MUIA_String_Contents, x);
  841. **
  842. **    Dos.PrintF( "gadget contains '%s'\n" , x );
  843. **
  844. ** NNset() sets an attribute without triggering a possible notification.
  845. **
  846. **
  847. ***************************************************************************)
  848.  
  849.   PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
  850.     BEGIN (* SaveReg+ *)
  851.       IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
  852.     END Set;
  853.  
  854.   PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
  855.     BEGIN (* SaveReg+ *)
  856.       IF I.GetAttr( attr, obj, store) = 0 THEN END
  857.     END Get;
  858.  
  859.   PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
  860.     BEGIN (* SaveReg+ *)
  861.       IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
  862.     END NNSet;
  863.  
  864.   PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
  865.     BEGIN (* SaveReg+ *)
  866.       Set( obj, m.aRadioActive, n );
  867.     END SetMutex;
  868.  
  869.   PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
  870.     BEGIN (* SaveReg+ *)
  871.       Set( obj, m.aCycleActive, n );
  872.     END SetCycle;
  873.  
  874.   PROCEDURE SetString * ( obj : m.Object; s : ARRAY OF CHAR );
  875.     BEGIN (* SaveReg+ *)
  876.       Set( obj, m.aStringContents, y.ADR( s ) );
  877.     END SetString;
  878.  
  879.   PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
  880.     BEGIN (* SaveReg+ *)
  881.       Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
  882.     END SetCheckmark;
  883.  
  884.   PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
  885.     BEGIN (* SaveReg+ *)
  886.       Set( obj, m.aSliderLevel, l );
  887.     END SetSlider;
  888.  
  889.   PROCEDURE MAKEID*( c1, c2, c3, c4 : CHAR):LONGINT;
  890.     BEGIN (* SaveReg+ *)
  891.       RETURN( y.LSH( ORD(c1), 24 )+
  892.               y.LSH( ORD(c2), 16 )+
  893.               y.LSH( ORD(c3),  8 )+
  894.               ORD(c4) )
  895.     END MAKEID;
  896.  
  897. BEGIN
  898.   IF m.base.version < 8 THEN HALT( 100 ) END;
  899. END MuiSimple.
  900.  
  901.  
  902.